﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Threading.Tasks;

using ScarecrowLibrary;
using ScarecrowLibrary.Network;
using ScarecrowLibrary.IO;

namespace Scarecrow_Network_Manager
{
    /// <summary>
    /// Logica di interazione per ProfileWindow.xaml
    /// </summary>
    public partial class oldProfileWindow : Window
    {
        #region Properties
        public string ToRemove
        {
            get;
            private set;
        }
        public string Profile
        {
            get;
            private set;
        }
        #endregion

        #region Fields
        string profileName;
        scNetworkProfile np;
        int icon = 0;
        string[] images;
        #endregion

        #region Methods
        public oldProfileWindow(string profileName)
        {
            try
            {
                InitializeComponent();
                this.images = System.IO.Directory.GetFiles(Properties.Settings.Default.ImagesPath);

                this.np = new scNetworkProfile();
                this.profileName = profileName;
                this.txtProfile.Text = profileName;

                //se profileName == null allora è un nuovo profilo, altrimenti carico da disco il profilo esistente
                if (!string.IsNullOrWhiteSpace(profileName))
                {
                    scXmlSerializer.Load(ref np, "np", System.IO.Path.Combine(Properties.Settings.Default.ProfilesPath, profileName));
                    this.txtProfile.Text = this.np.Name;
                    for (int i = 0; i < images.Length; i++)
                    {
                        if (np.ImagePath == images[i])
                        {
                            this.icon = i;
                            break;
                        }
                    }
                }
                else
                {
                    //Altrimenti carico tutte le schede impostate come disabilitate
                    scNetworkAdapter[] nics = scNetworkAdapter.GetAllInterfaces();
                    foreach (scNetworkAdapter nic in nics)
                    {
                        scAdapterProfile profile = new scAdapterProfile();
                        profile.NetworkAdapter = nic.ConnectionName;
                        profile.Enabled = profile.IsIPDhcp = profile.IsDNSDhcp = false;
                        profile.IPAddress = profile.SubnetMask = profile.Gateway = profile.DNS1 = profile.DNS2 = "";
                        this.np.AddAdapterProfile(profile);
                    }
                }

                this.adaptersGrid.DataContext = this.np.GetProfiles();
                this.adaptersGrid.Items.Refresh();

                Image image = Global.LoadImageFromPath(this.images[this.icon]);
                this.pcbIcon.Source = image.Source;
            }
            catch (Exception exc)
            {
                Global.NotifyCrash("Si è verificato un errore durante l'inizializzazione della finestra di configurazione del profilo.", exc);
            }
        }

        private void cmdEditAdapter_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (this.adaptersGrid.SelectedItem != null)
                {
                    scAdapterProfile adapter = (this.adaptersGrid.SelectedItem as scAdapterProfile);
                    if (adapter != null)
                    {
                        AdapterWindow window = new AdapterWindow(adapter);
                        window.ShowDialog();
                        if (window.Profile != null)
                        {
                            this.np.RemoveAdapterProfile(adapter.NetworkAdapter);
                            this.np.AddAdapterProfile(window.Profile);
                            this.adaptersGrid.DataContext = this.np.GetProfiles();
                            this.adaptersGrid.Items.Refresh();
                        }
                        this.adaptersGrid.Focus();
                    }
                }
            }
            catch (Exception exc)
            {
                Global.NotifyCrash("Si è verificato un errore durante l'aggiunta di un nuovo adattatore al profilo", exc);
            }
        }

        private void cmdClose_Click(object sender, RoutedEventArgs e)
        {
            this.Profile = null;
            this.Close();
        }

        private void cmdSave_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(this.txtProfile.Text))
                    return;

                string path = System.IO.Path.Combine(Properties.Settings.Default.ProfilesPath, this.txtProfile.Text);

                //Se this.profileName == null, allora è un nuovo profilo! altrimenti se non è vuoto
                //ed è diverso dal nome che ha immesso l'utente
                if (!string.IsNullOrWhiteSpace(this.profileName) && this.profileName != this.txtProfile.Text)
                {
                    string oldPath = System.IO.Path.Combine(Properties.Settings.Default.ProfilesPath, this.profileName);
                    //bisogna far fuori il vecchio file e crearne uno con il nuovo nome
                    if (System.IO.File.Exists(oldPath))
                        System.IO.File.Delete(oldPath);
                }

                //Controllo se esiste già un file con quel nome
                if (System.IO.File.Exists(path))
                    if (MessageBox.Show("Esiste già un profilo con il nome \"" + this.txtProfile.Text + "\"" + Environment.NewLine + "Sovrascrivere?", "Attenzione!", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.No)
                        return;
                    else
                        System.IO.File.Delete(path);

                // Controllo che non ci sia già un file con queste impostazioni
                string oldProfile = ToRemove = CheckDuplicate(np);
                if (!scStringTools.IsNullOrWhiteSpace(oldProfile))
                {
                    // Lo devo comunicare all'utente
                    if (MessageBox.Show(string.Format("Il profilo \"{0}\" ed il profilo corrente coincidono. Sovrascrivere il vecchio profilo?", oldProfile), "Attenzione", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                    {
                        // Se lo vuole aggiornare, cancello quello vecchio
                        System.IO.File.Delete(System.IO.Path.Combine(Properties.Settings.Default.ProfilesPath, oldProfile));
                    }
                    else
                    {
                        //Altrimenti esco
                        return;
                    }
                }

                this.np.ImagePath = this.images[this.icon];

                scXmlSerializer.Save(this.np, "np", path);
                this.Profile = this.txtProfile.Text;
                
                this.Close();
            }
            catch (Exception exc)
            {
                Global.NotifyCrash("Si è verificato un errore durante il salvataggio del profilo.", exc);
            }
        }
        string CheckDuplicate(scNetworkProfile np)
        {
            string[] profiles = System.IO.Directory.GetFiles(Properties.Settings.Default.ProfilesPath);
            string originalName = np.Name, match = null;
            foreach (string profile in profiles)
            {
                scNetworkProfile loaded = new scNetworkProfile();
                scXmlSerializer.Load(ref loaded, "np", profile);
                np.Name = loaded.Name;
                np.ImagePath = loaded.ImagePath;
                if (loaded == np)
                {
                    match = loaded.Name;
                    break;
                }
            }
            np.Name = originalName;
            return match;
        }
        private void txtProfile_TextChanged(object sender, TextChangedEventArgs e)
        {
            this.np.Name = this.txtProfile.Text;
        }

        private void cmdNextIcon_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                this.icon++;
                Image image = Global.LoadImageFromPath(this.images[this.icon]);
                this.pcbIcon.Source = image.Source;
            }
            catch
            {
                this.icon--;
            }
        }

        private void cmdPrevIcon_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                this.icon--;
                Image image = Global.LoadImageFromPath(this.images[this.icon]);
                this.pcbIcon.Source = image.Source;
            }
            catch
            {
                this.icon++;
            }
        }

        private void adaptersGrid_MouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            cmdEditAdapter_Click(sender, null);
        }
        #endregion
    }
}
